// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © TFlab
//@version=5
indicator("Breaker Blocks + Order Blocks OverLap ICT [TradingFinder] BBOB" ,'TFlab Overlapping Block', overlay = true, max_bars_back = 5000, max_boxes_count = 500,max_labels_count = 500, max_lines_count = 500 )

//import Libraries
    //import Order Block Refiner
import TFlab/OrderBlockRefiner_TradingFinder/2 as Refiner
    //import Order Block Drawing  Library
import TFlab/OrderBlockDrawing_TradingFinder/4 as Drawing
    //import Order Block Overlapping
import TFlab/OrderBlockOverlappingDrawing/1 as OLB
    //import Alert Sender Library
import TFlab/AlertSenderLibrary_TradingFinder/1 as Alert
    //import Switching Colors Theme
import TFlab/Dark_Light_Theme_TradingFinder_Switching_Colors_Library/1 as SC
    //import Tradingview Technical Analysis Library
import TradingView/ta/7



//Input 

    //Pivot Period of Order Blocks Detector
PP = input.int(9, 'Pivot Period of Order Blocks Detector' , group = 'Global Setting' , minval = 1)
OBVaP = input.int(500, 'Order Block Validity Period (Bar)' , group = 'Global Setting' , maxval = 4998 , minval = 10,
 tooltip = 'You can set the validity period of each Order Block based on the number of candles that have passed since the origin of the Order Block.')
MLOB = input.string('Proximal' , 'Mitigation Level OB', ['Proximal', '50 % OB', 'Distal'], 
 tooltip= 'Using this entry, you can determine which level the price reacts to in a Order Block.', group = 'Global Setting')
MLBB = input.string('Proximal' , 'Mitigation Level BB', ['Proximal', '50 % BB', 'Distal'], 
 tooltip= 'Using this entry, you can determine which level the price reacts to in a Breaker Block.', group = 'Global Setting')
MLOL = input.string('Proximal' , 'Mitigation Level OLB', ['Proximal', '50 % BB', 'Distal'], 
 tooltip= 'Using this entry, you can determine which level the price reacts to in a OverLapping Block.', group = 'Global Setting') 
SCMode = input.string('Light', 'Switching Colors Theme Mode', options = ['Off', 'Light', 'Dark'], group = 'Global Setting')

    //Display Overlapping Block
ShowAllOLB = input.bool(true, 'Show All OB', group = 'Disply OverLapping Block')

DOLBShow  = input.bool(true, 'Demand OverLapping Block', inline = 'DMOLB', group = 'Disply OverLapping Block')
DOLBColorO = input.color(color.rgb(16, 182, 219, 58), '', inline = 'DMOLB', group = 'Disply OverLapping Block')

SOLBBShow  = input.bool(true, 'Supply OverLapping Block', inline = 'SSOLB', group = 'Disply OverLapping Block')
SOLBColorO = input.color(color.rgb(255, 108, 3, 55), '', inline = 'SSOLB', group = 'Disply OverLapping Block')

    //Display Order Blocks
ShowAllOB = input.bool(true, 'Show All OB', group = 'Disply Order Blocks')

DMOBShow  = input.bool(false, 'Demand Main Order Block', inline = 'DMOB', group = 'Disply Order Blocks')
DMOBColorO = input.color(color.rgb(60, 176, 68, 55), '', inline = 'DMOB', group = 'Disply Order Blocks')

DSOBShow  = input.bool(false, 'Demand  Sub Order Block', inline = 'DSOB', group = 'Disply Order Blocks')
DSOBColorO = input.color(color.rgb(60, 176, 68, 55), '', inline = 'DSOB', group = 'Disply Order Blocks')

SMOBShow  =  input.bool(false, 'Supply  Main  Order Block', inline = 'SMOB', group = 'Disply Order Blocks')
SMOBColorO = input.color(color.rgb(191, 10, 48 , 55), '', inline = 'SMOB', group = 'Disply Order Blocks')

SSOBShow  = input.bool(false, 'Supply  Sub  Order  Block', inline = 'SSOB', group = 'Disply Order Blocks')
SSOBColorO = input.color(color.rgb(191, 10, 48 , 55), '', inline = 'SSOB', group = 'Disply Order Blocks')


    //Display Breaker Blocks
ShowAllBB = input.bool(true, 'Show All BB', group = 'Disply Breaker Blocks')

DMBBShow  = input.bool(true, 'Demand Main Breaker Block', inline = 'DMBB', group = 'Disply Breaker Blocks')
DMBBColorO= input.color(color.rgb(123, 180, 227, 50), '', inline = 'DMBB', group = 'Disply Breaker Blocks')

DSBBShow  = input.bool(true, 'Demand  Sub Breaker Block', inline = 'DSBB', group = 'Disply Breaker Blocks')
DSBBColorO = input.color(color.rgb(153, 237, 195, 60), '', inline = 'DSBB', group = 'Disply Breaker Blocks')

SMBBShow  =  input.bool(true, 'Supply  Main  Breaker Block', inline = 'SMBBS', group = 'Disply Breaker Blocks')
SMBBColorO = input.color(color.rgb(255, 105, 97, 70), '', inline = 'SMBBS', group = 'Disply Breaker Blocks')

SSBBShow  = input.bool(true, 'Supply  Sub  Breaker  Block', inline = 'SSBB', group = 'Disply Breaker Blocks')
SSBBColorO = input.color(color.rgb(243, 189, 74, 60), '', inline = 'SSBB', group = 'Disply Breaker Blocks')
 


    //Refinement Order Blocks, display and Method

RefineDmainCh = input.bool(true, 'Refine Demand Main', 
 'If you want this "Demand Main Order Block, ChoCh Origin" to be refined to display a optimal range,' +
 'you should select "On" and if you want to see the original' +
 'range of the block order, you should select "Off".' + 
 '\nAlso, if you are a risk taker, you can choose the "Aggressive" Refine method,' + 
 'and if you are risk averse, you can choose the "Defensive" Refine method.'
 , group ='Order Blocks Refinement ', inline = 'Refine 1')

RefineMeDmainCh = input.string('Defensive', '', ['Defensive', 'Aggressive'] , 
 group = 'Order Blocks Refinement ' , inline = 'Refine 1')

RefineDsubCh  = input.bool(true, 'Refine Demand Sub.',
 'If you want this "Demand Sub Order Block, ChoCh Origin" to be refined to display a optimal range,' +
 'you should select "On" and if you want to see the original' +
 'range of the block order, you should select "Off".' + 
 '\nAlso, if you are a risk taker, you can choose the "Aggressive" Refine method,' + 
 'and if you are risk averse, you can choose the "Defensive" Refine method.' 
 , group ='Order Blocks Refinement ', inline = 'Refine 2')

RefineMeDsubCh  = input.string('Defensive', '', ['Defensive', 'Aggressive'] , 
 group = 'Order Blocks Refinement ', inline = 'Refine 2')



RefineSmainCh = input.bool(true, 'Refine Supply Main..', 
 'If you want this "Supply Main Order Block, ChoCh Origin" to be refined to display a optimal range,' +
 'you should select "On" and if you want to see the original' +
 'range of the block order, you should select "Off".' + 
 '\nAlso, if you are a risk taker, you can choose the "Aggressive" Refine method,' + 
 'and if you are risk averse, you can choose the "Defensive" Refine method.' 
 , group ='Order Blocks Refinement ', inline = 'Refine 4')

RefineMeSmainCh = input.string('Defensive', '', ['Defensive', 'Aggressive'] , 
 group = 'Order Blocks Refinement ', inline = 'Refine 4')

RefineSsubCh  = input.bool(true, 'Refine Supply Sub...', 
 'If you want this "Supply Sub Order Block, ChoCh Origin" to be refined to display a optimal range,' +
 'you should select "On" and if you want to see the original' +
 'range of the block order, you should select "Off".' + 
 '\nAlso, if you are a risk taker, you can choose the "Aggressive" Refine method,' + 
 'and if you are risk averse, you can choose the "Defensive" Refine method.' 
 , group ='Order Blocks Refinement ', inline = 'Refine 5')

RefineMeSsubCh  =  input.string('Defensive', '', ['Defensive', 'Aggressive'] , 
 group = 'Order Blocks Refinement ', inline = 'Refine 5')


    //Alert
    //Alert
AlertName = input.string('OB & BB OverLapping [TradingFinder]', 'Alerts Name', group = 'Alert')

Alert_OLP = input.string('On' , 'Alert OB & BB OverLapping Mitigation' , ['On', 'Off'], 'If you turn on the Alert OB & BB OverLapping Order Block Mitigation,' + 
 'you can receive alerts and notifications after setting the "Alert".' , group = 'Alert')


Frequncy = input.string('Once Per Bar' , 'Message Frequency' , ['All', 'Once Per Bar' , 'Per Bar Close'], 'The triggering frequency. Possible values are: All'+ 
 ' (all function calls trigger the alert), Once Per Bar (the first function call during the bar triggers the alert), ' +  
 ' Per Bar Close (the function call triggers the alert only when it occurs during the last script iteration of the real-time bar,' +  
 ' when it closes). The default is alert.freq_once_per_bar.)', group = 'Alert')
UTC = input.string('UTC' , 'Show Alert time by Time Zone', group = 'Alert')



//Colors Adjusment

    // Order Blocks

[DMOBColor] = SC.SwitchingColorMode(DMOBColorO , SCMode)

[DSOBColor] = SC.SwitchingColorMode(DSOBColorO , SCMode)

[SMOBColor] = SC.SwitchingColorMode(SMOBColorO , SCMode)

[SSOBColor] = SC.SwitchingColorMode(SSOBColorO , SCMode)


    // Breaker Blocks
  
[DMBBColor] = SC.SwitchingColorMode(DMBBColorO , SCMode)

[DSBBColor] = SC.SwitchingColorMode(DSBBColorO , SCMode)

[SMBBColor] = SC.SwitchingColorMode(SMBBColorO , SCMode)

[SSBBColor] = SC.SwitchingColorMode(SSBBColorO , SCMode)
 


    // Overlapping Blocks
  
[DOLBColor] = SC.SwitchingColorMode(DOLBColorO , SCMode)

[SOLBColor] = SC.SwitchingColorMode(SOLBColorO , SCMode)


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


//Variables

    //ZigZag Data
Open = open
High = high
Low = low
Close = close 
Bar_Index = bar_index
ATR =ta.atr(55)
var ArrayType = array.new_string()
var ArrayValue = array.new_float()
var ArrayIndex =  array.new_int()
var ArrayTypeAdv  = array.new_string()
var ArrayValueAdv = array.new_float()
var ArrayIndexAdv =  array.new_int()  
var line ZZLine = na
var line Sline = na 
var line Rline = na 
var label Label  = na
PASS = 0
HighPivot = ta.pivothigh(PP,PP)
LowPivot = ta.pivotlow(PP,PP)
HighValue = ta.valuewhen(HighPivot ,High[PP], 0)
LowValue = ta.valuewhen(LowPivot ,Low[PP], 0)
HighIndex = ta.valuewhen(HighPivot ,Bar_Index[PP], 0)
LowIndex = ta.valuewhen(LowPivot ,Bar_Index[PP], 0)
Correct_HighPivot = 0.0
Correct_LowPivot =  0.0

    //Major Levels
var float Major_HighLevel = na
var float Major_LowLevel  = na

var int Major_HighIndex = na
var int Major_LowIndex = na

var string Major_HighType= na
var string Major_LowType = na

    //Minor Levels
var float Minor_HighLevel = na
var float Minor_LowLevel  = na

var int Minor_HighIndex   = na
var int Minor_LowIndex    = na

var string Minor_HighType = na
var string Minor_LowType  = na

var int LockDetecteM_MinorLvL = 0

    //
var bool Lock0 = true
var bool Lock1 = true

// Detecte Major & Minor Pivot
// Order Blocks Data
    //Major
var int LastMHH = 0
var int Last02MHH = 0
var int LastMLH = 0

var int LastMLL = 0
var int Last02MLL = 0
var int LastMHL = 0
    //Minor
var int LastmHH = 0
var int Last02mHH = 0
var int LastmLH = 0

var int LastmLL = 0
var int Last02mLL = 0
var int LastmHL = 0

/////////////////////////////
// Last Pivot First Point////
/////////////////////////////
var string LastPivotType = na
var int LastPivotIndex = 0

var string LastPivotType02 = na
var int LastPivotIndex02 = 0

    //Major 01
var float MajorHighValue01 = na
var int   MajorHighIndex01 = na
var string MajorHighType01 = ''

var float MajorLowValue01  = na
var int   MajorLowIndex01 =  na
var string MajorLowType01 =  ''

    //Minor 01
var float MinorHighValue01 = na
var int   MinorHighIndex01 = na
var string MinorHighType01 = ''

var float MinorLowValue01  = na
var int   MinorLowIndex01  = na
var string MinorLowType01 =  ''

/////////////////////////////////////
//One to the Last Pivot First Point//
/////////////////////////////////////
    //Major 02
var float MajorHighValue02 = na
var int   MajorHighIndex02 = na
var string MajorHighType02 = ''

var float MajorLowValue02  = na
var int   MajorLowIndex02 =  na
var string MajorLowType02 =  ''

    //Minor 02
var float MinorHighValue02 = na
var int   MinorHighIndex02 = na
var string MinorHighType02 = ''

var float MinorLowValue02  = na
var int   MinorLowIndex02  = na
var string MinorLowType02 =  ''

    //Major 02 Change Type Pivot
var float MajorHighValue02Ch = na
var int   MajorHighIndex02Ch = na
var string MajorHighType02Ch = ''

var float MajorLowValue02Ch  = na
var int   MajorLowIndex02Ch =  na
var string MajorLowType02Ch =  ''

    //Lines Data
var line MajorLine_ChoChBull   = na
var label MajorLabel_ChoChBull = na

var line MajorLine_ChoChBear   = na
var label MajorLabel_ChoChBear = na

var line MajorLine_BoSBull     = na
var label MajorLabel_BoSBull   = na

var line MajorLine_BoSBear     = na
var label MajorLabel_BoSBear   = na

var line MinorLine_ChoChBull   = na
var label MinorLabel_ChoChBull = na

var line MinorLine_ChoChBear   = na
var label MinorLabel_ChoChBear = na

var line MinorLine_BoSBull     = na
var label MinorLabel_BoSBull   = na

var line MinorLine_BoSBear     = na
var label MinorLabel_BoSBear   = na

    // BoS & ChoCh Data
        //Major
var bool Bullish_Major_ChoCh = false
var bool Bullish_Major_BoS = false

var bool Bearish_Major_ChoCh = false
var bool Bearish_Major_BoS = false

var BoS_MajorType  = array.new_string()
var BoS_MajorIndex = array.new_int()

var ChoCh_MajorType  = array.new_string()
var ChoCh_MajorIndex = array.new_int()

var int LockBreak_M = 0 

        //Minor
var bool Bullish_Minor_ChoCh = false
var bool Bullish_Minor_BoS = false

var bool Bearish_Minor_ChoCh = false
var bool Bearish_Minor_BoS = false

var BoS_MinorType  = array.new_string()
var BoS_MinorIndex = array.new_int()

var ChoCh_MinorType  = array.new_string()
var ChoCh_MinorIndex = array.new_int()

var int LockBreak_m = 0 


    //Support & Resistance Line

        //Major
var line Support_LineMajor = na 
var line Resistance_LineMajor = na 
        //Minor
var line Support_LineMinor = na
var line Resistance_LineMinor = na

    //Trend Data

var string ExternalTrend = 'No Trend'
var string InternalTrend = 'No Trend'

    //Order Blocks Data

        //Bullish Major ChoCh Main
var bool  BuMChMain_Trigger = false
var int   BuMChMain_Index     = 0

        //Bullish Major ChoCh Sub
var bool  BuMChSub_Trigger = false
var int   BuMChSub_Index     = 0

        //Bullish Major BoS
var bool  BuMBoS_Trigger = false
var int   BuMBoS_Index     = 0

        //Bearish Major ChoCh Main
var bool  BeMChMain_Trigger = false
var int   BeMChMain_Index     = 0

        //Bearish Major ChoCh Sub
var bool  BeMChSub_Trigger = false
var int   BeMChSub_Index     = 0

        //Bearish Major BoS
var bool  BeMBoS_Trigger = false
var int   BeMBoS_Index     = 0

    //Correction OB
        //Bullish Major ChoCh 

var float ChBuLowest = 0.0
var float ChBuLowestSub = 0.0

var int CorrectBuIndex = 0
var int CorrectBuIndexSub = 0

        //Bullish Major BoS

var float BoSBuLowest = 0.0
var float BoSBuLowest02 = 0.0

var int CorrectBuBoSIndex = 0
var int CorrectBuBoSIndex02 = 0

        //Bearish Major ChoCh 

var float ChBeHighest = 0.0
var float ChBeHighestSub = 0.0

var int CorrectBeIndex = 0
var int CorrectBeIndexSub = 0

        //Bearish Major BoS 

var float BoSBeHighest = 0.0
var float BoSBeHighest02 = 0.0

var int CorrectBeBoSIndex = 0
var int CorrectBeBoSIndex02 = 0


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////Calculation/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    //{Zig Zag}
if HighPivot  and  LowPivot
    if ArrayType.size() == 0
        PASS := 1
    else if ArrayType.size() >= 1
        if ((ArrayType.get(ArrayType.size() - 1)) == "L" or
             (ArrayType.get(ArrayType.size() - 1)) == "LL")
            if LowPivot < ArrayValue.get(ArrayType.size() - 1)
                array.remove(ArrayType,ArrayType.size() - 1)
                array.remove(ArrayValue,ArrayValue.size() - 1)
                array.remove(ArrayIndex,ArrayIndex.size() - 1) 
                array.push(ArrayType,ArrayType.size()>2? ArrayValue.get(ArrayType.size() - 2) < LowValue ? "HL" : "LL" : "L")///////////////////////////////Here
                array.push(ArrayValue, LowValue)
                array.push(ArrayIndex, LowIndex)
                Correct_LowPivot :=  LowValue
            else 
                array.push(ArrayType,ArrayType.size()>2? ArrayValue.get(ArrayType.size() - 2) < HighValue ? "HH" : "LH" : "H" ) ///////////////////////////////Here
                array.push(ArrayValue, HighValue)
                array.push(ArrayIndex, HighIndex)
            Correct_HighPivot := HighValue  
        else if (ArrayType.get(ArrayType.size() - 1)) == "H" or 
             (ArrayType.get(ArrayType.size() - 1)) == "HH"
            if HighPivot > ArrayValue.get(ArrayType.size() - 1)
                array.remove(ArrayType,ArrayType.size() - 1)
                array.remove(ArrayValue,ArrayValue.size() - 1)
                array.remove(ArrayIndex,ArrayIndex.size() - 1)
                array.push(ArrayType,ArrayType.size()>2? ArrayValue.get(ArrayType.size() - 2) < HighValue ? "HH" : "LH" : "H")///////////////////////////////Here
                array.push(ArrayValue, HighValue)
                array.push(ArrayIndex, HighIndex)
                Correct_HighPivot := HighValue  
            else 
                array.push(ArrayType,ArrayType.size()>2?  ArrayValue.get(ArrayType.size() - 2) < LowValue ? "HL" : "LL" : "L")///////////////////////////////Here
                array.push(ArrayValue, LowValue)
                array.push(ArrayIndex, LowIndex)
            Correct_LowPivot :=  LowValue    
        else if (ArrayType.get(ArrayType.size() - 1)) == "LH"
            if HighPivot < ArrayValue.get(ArrayType.size() - 1)
                array.push(ArrayType,ArrayType.size()>2?  ArrayValue.get(ArrayType.size() - 2) < LowValue ? "HL" : "LL" : "L")///////////////////////////////Here
                array.push(ArrayValue, LowValue)
                array.push(ArrayIndex, LowIndex)
                Correct_LowPivot :=  LowValue 
            else if HighPivot > ArrayValue.get(ArrayType.size() - 1)
                if close < ArrayValue.get(ArrayType.size() - 1)
                    array.remove(ArrayType,ArrayType.size() - 1)
                    array.remove(ArrayValue,ArrayValue.size() - 1)
                    array.remove(ArrayIndex,ArrayIndex.size() - 1)
                    array.push(ArrayType,ArrayType.size()>2? ArrayValue.get(ArrayType.size() - 2) < HighValue ? "HH" : "LH" : "H")///////////////////////////////Here
                    array.push(ArrayValue, HighValue)
                    array.push(ArrayIndex, HighIndex)
                    Correct_HighPivot := HighValue  
                else if close > ArrayValue.get(ArrayType.size() - 1)
                    array.push(ArrayType,ArrayType.size()>2? ArrayValue.get(ArrayType.size() - 2) < LowValue ? "HL" : "LL" : "L")///////////////////////////////Here
                    array.push(ArrayValue, LowValue)
                    array.push(ArrayIndex, LowIndex)
                    Correct_LowPivot :=  LowValue
        else if (ArrayType.get(ArrayType.size() - 1)) == "HL"
            if LowPivot > ArrayValue.get(ArrayType.size() - 1)
                array.push(ArrayType,ArrayType.size()>2? ArrayValue.get(ArrayType.size() - 2) < HighValue ? "HH" : "LH" : "H" ) ///////////////////////////////Here
                array.push(ArrayValue, HighValue)
                array.push(ArrayIndex, HighIndex)
                Correct_HighPivot := HighValue                       
            else if LowPivot < ArrayValue.get(ArrayType.size() - 1)
                if close > ArrayValue.get(ArrayType.size() - 1)
                    array.remove(ArrayType,ArrayType.size() - 1)
                    array.remove(ArrayValue,ArrayValue.size() - 1)
                    array.remove(ArrayIndex,ArrayIndex.size() - 1) 
                    array.push(ArrayType,ArrayType.size()>2? ArrayValue.get(ArrayType.size() - 2) < LowValue ? "HL" : "LL" : "L")///////////////////////////////Here
                    array.push(ArrayValue, LowValue)
                    array.push(ArrayIndex, LowIndex)
                    Correct_LowPivot :=  LowValue
                else if close < ArrayValue.get(ArrayType.size() - 1)
                    array.push(ArrayType,ArrayType.size()>2? ArrayValue.get(ArrayType.size() - 2) < HighValue ? "HH" : "LH" : "H")///////////////////////////////Here
                    array.push(ArrayValue, HighValue)
                    array.push(ArrayIndex, HighIndex)
                    Correct_HighPivot := HighValue                         
else if  HighPivot 
    if ArrayType.size() == 0
        array.insert(ArrayType, 0, "H")
        array.insert(ArrayValue, 0, HighValue)
        array.insert(ArrayIndex, 0, HighIndex)
        Correct_HighPivot := HighValue
    else if ArrayType.size() >= 1
        if ((ArrayType.get(ArrayType.size() - 1)) == "L" or
             (ArrayType.get(ArrayType.size() - 1)) == "HL" or
             (ArrayType.get(ArrayType.size() - 1)) == "LL")
            if HighPivot > ArrayValue.get(ArrayType.size() - 1)
                array.push(ArrayType,ArrayType.size()>2? ArrayValue.get(ArrayType.size() - 2) < HighValue ? "HH" : "LH" : "H" ) ///////////////////////////////Here
                array.push(ArrayValue, HighValue)
                array.push(ArrayIndex, HighIndex)
                Correct_HighPivot := HighValue
            else if  HighPivot < ArrayValue.get(ArrayType.size() - 1)
                array.remove(ArrayType,ArrayType.size() - 1)
                array.remove(ArrayValue,ArrayValue.size() - 1)
                array.remove(ArrayIndex,ArrayIndex.size() - 1) 
                array.push(ArrayType,ArrayType.size()>2? ArrayValue.get(ArrayType.size() - 2) < LowValue ? "HL" : "LL" : "L")///////////////////////////////Here
                array.push(ArrayValue, LowValue)
                array.push(ArrayIndex, LowIndex)
                Correct_LowPivot :=  LowValue                         
        else if (ArrayType.get(ArrayType.size() - 1)) == "H" or 
             (ArrayType.get(ArrayType.size() - 1)) == "HH" or 
             (ArrayType.get(ArrayType.size() - 1)) == "LH"
            if (ArrayValue.get(ArrayValue.size() - 1)) < HighValue
                array.remove(ArrayType,ArrayType.size() - 1)
                array.remove(ArrayValue,ArrayValue.size() - 1)
                array.remove(ArrayIndex,ArrayIndex.size() - 1)
                array.push(ArrayType,ArrayType.size()>2? ArrayValue.get(ArrayType.size() - 2) < HighValue ? "HH" : "LH" : "H")///////////////////////////////Here
                array.push(ArrayValue, HighValue)
                array.push(ArrayIndex, HighIndex)
                Correct_HighPivot := HighValue               
else if LowPivot 
    if ArrayType.size() == 0
        array.insert(ArrayType, 0, "L")
        array.insert(ArrayValue, 0, LowValue)
        array.insert(ArrayIndex, 0, LowIndex)
        Correct_LowPivot :=  LowValue
    else if ArrayType.size() >= 1
        if (ArrayType.get(ArrayType.size() - 1)) == "H" or 
             (ArrayType.get(ArrayType.size() - 1)) == "HH" or 
             (ArrayType.get(ArrayType.size() - 1)) == "LH"
            if LowPivot < ArrayValue.get(ArrayType.size() - 1)
                array.push(ArrayType,ArrayType.size()>2?  ArrayValue.get(ArrayType.size() - 2) < LowValue ? "HL" : "LL" : "L")///////////////////////////////Here
                array.push(ArrayValue, LowValue)
                array.push(ArrayIndex, LowIndex)
                Correct_LowPivot :=  LowValue
            else if LowPivot > ArrayValue.get(ArrayType.size() - 1)
                array.remove(ArrayType,ArrayType.size() - 1)
                array.remove(ArrayValue,ArrayValue.size() - 1)
                array.remove(ArrayIndex,ArrayIndex.size() - 1)
                array.push(ArrayType,ArrayType.size()>2? ArrayValue.get(ArrayType.size() - 2) < HighValue ? "HH" : "LH" : "H")///////////////////////////////Here
                array.push(ArrayValue, HighValue)
                array.push(ArrayIndex, HighIndex)
                Correct_HighPivot := HighValue                        
        else if (ArrayType.get(ArrayType.size() - 1)) == "L" or 
             (ArrayType.get(ArrayType.size() - 1)) == "HL" or 
             (ArrayType.get(ArrayType.size() - 1)) == "LL"
            if (ArrayValue.get(ArrayValue.size() - 1)) > LowValue
                array.remove(ArrayType,ArrayType.size() - 1)
                array.remove(ArrayValue,ArrayValue.size() - 1)
                array.remove(ArrayIndex,ArrayIndex.size() - 1) 
                array.push(ArrayType,ArrayType.size()>2? ArrayValue.get(ArrayType.size() - 2) < LowValue ? "HL" : "LL" : "L")///////////////////////////////Here
                array.push(ArrayValue, LowValue)
                array.push(ArrayIndex, LowIndex)
                Correct_LowPivot :=  LowValue

    //{Zig Zag Advance}

        //first Major & Minor Detector
if ArrayType.size() ==  2
    if ArrayType.get(0) == 'H'
        Major_HighLevel := ArrayValue.get(0)
        Major_LowLevel  := ArrayValue.get(1)
        Major_HighIndex := ArrayIndex.get(0)
        Major_LowIndex  := ArrayIndex.get(1)
        Major_HighType := ArrayType.get(0)
        Major_LowType  := ArrayType.get(1)
    else if ArrayType.get(0) == 'L'
        Major_HighLevel := ArrayValue.get(1)
        Major_LowLevel  := ArrayValue.get(0) 
        Major_HighIndex := ArrayIndex.get(1)
        Major_LowIndex  := ArrayIndex.get(0)
        Major_HighType := ArrayType.get(1)
        Major_LowType  := ArrayType.get(0)

        //Making Copies of Arrays


if  ArrayValue.size() == 1
    if Lock0
        array.insert(ArrayTypeAdv ,0 ,'M' +  ArrayType.get(0))
        array.insert(ArrayValueAdv,0 ,ArrayValue.get(0))
        array.insert(ArrayIndexAdv,0 ,ArrayIndex.get(0))   
        Lock0 := false

if  ArrayValue.size() == 2
    if Lock1
        array.insert(ArrayTypeAdv ,1 ,'M' +  ArrayType.get(1))
        array.insert(ArrayValueAdv,1 ,ArrayValue.get(1))
        array.insert(ArrayIndexAdv,1 ,ArrayIndex.get(1))   
        Lock1 := false

if ArrayValue.size() > 1
    if ArrayValue.get(ArrayValue.size()-1)[1] != ArrayValue.get(ArrayValue.size()-1)
        if str.substring(ArrayType.get(ArrayType.size()-1)[1], str.length(ArrayType.get(ArrayType.size()-1))-1) != 
             str.substring(ArrayType.get(ArrayType.size()-1), str.length(ArrayType.get(ArrayType.size()-1))-1)
            array.push(ArrayTypeAdv ,'m' +  ArrayType.get(ArrayType.size()   - 1))
            array.push(ArrayValueAdv, ArrayValue.get(ArrayValue.size() - 1))
            array.push(ArrayIndexAdv, ArrayIndex.get(ArrayIndex.size() - 1))
        else if str.substring(ArrayType.get(ArrayType.size()-1)[1], str.length(ArrayType.get(ArrayType.size()-1))-1) == 
             str.substring(ArrayType.get(ArrayType.size()-1), str.length(ArrayType.get(ArrayType.size()-1))-1)
            array.remove(ArrayValueAdv, ArrayValueAdv.size() - 1)
            array.remove(ArrayIndexAdv, ArrayIndexAdv.size() - 1)
            array.push(ArrayValueAdv, ArrayValue.get(ArrayValue.size() - 1))
            array.push(ArrayIndexAdv, ArrayIndex.get(ArrayIndex.size() - 1))

        //All Major & Minor Pivot Detector 

if ArrayValueAdv.size() > 1
            //High Major Detector
    if close > Major_HighLevel
        if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mL'
            ArrayTypeAdv.remove(ArrayTypeAdv.size() - 1)
            ArrayTypeAdv.push('ML')
            Major_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
            Major_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
            Major_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mHL'
            ArrayTypeAdv.remove(ArrayTypeAdv.size() - 1)
            ArrayTypeAdv.push('M' + ArrayType.get(ArrayType.size() - 1))      
            Major_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
            Major_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
            Major_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) 
        else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mLL'
            ArrayTypeAdv.remove(ArrayTypeAdv.size() - 1)
            ArrayTypeAdv.push('M'  + ArrayType.get(ArrayType.size() - 1)) 
            Major_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
            Major_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
            Major_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mLH' or ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mHH' or 
             ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'MLH' or ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'MHH' 
            if ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) == 'mHL'
                ArrayTypeAdv.remove(ArrayTypeAdv.size() - 2)
                ArrayTypeAdv.insert(ArrayValueAdv.size() - 2 , 'M' + ArrayType.get(ArrayType.size() - 2))      
                Major_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 2)
                Major_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 2)
                Major_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)
            else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) == 'mLL'
                ArrayTypeAdv.remove(ArrayTypeAdv.size() - 2)
                ArrayTypeAdv.insert(ArrayValueAdv.size() - 2 , 'M' + ArrayType.get(ArrayType.size() - 2))
                Major_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 2)
                Major_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 2)
                Major_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

    if  ArrayValueAdv.get(ArrayValueAdv.size() - 1) > Major_HighLevel
        if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mH'
            ArrayTypeAdv.remove(ArrayTypeAdv.size() - 1)
            ArrayTypeAdv.push('MH')
            Major_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
            Major_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
            Major_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mLH'
            ArrayTypeAdv.remove(ArrayTypeAdv.size() - 1)
            ArrayTypeAdv.push('M' + ArrayType.get(ArrayType.size() - 1))  
            Major_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
            Major_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
            Major_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)     
        else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mHH' or ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'MHH'
            ArrayTypeAdv.remove(ArrayTypeAdv.size() - 1)
            ArrayTypeAdv.push('M' + ArrayType.get(ArrayType.size() - 1))
            Major_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
            Major_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
            Major_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)

            //Low Major Detector
    if close < Major_LowLevel
        if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mH'
            ArrayTypeAdv.remove(ArrayTypeAdv.size() - 1)
            ArrayTypeAdv.push('MH')
            Major_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
            Major_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
            Major_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mLH'
            ArrayTypeAdv.remove(ArrayTypeAdv.size() - 1)
            ArrayTypeAdv.push('M' +  ArrayType.get(ArrayType.size() - 1))      
            Major_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
            Major_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
            Major_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mHH'
            ArrayTypeAdv.remove(ArrayTypeAdv.size() - 1)
            ArrayTypeAdv.push('M' + ArrayType.get(ArrayType.size() - 1))
            Major_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
            Major_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
            Major_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mHL' or ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mLL' or 
             ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'MHL' or ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'MLL'
            if ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) == 'mLH'
                ArrayTypeAdv.remove(ArrayTypeAdv.size() - 2)
                ArrayTypeAdv.insert(ArrayValueAdv.size() - 2 , 'M' + ArrayType.get(ArrayType.size() - 2))      
                Major_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 2)
                Major_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 2)
                Major_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)
            else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) == 'mHH'
                ArrayTypeAdv.remove(ArrayTypeAdv.size() - 2)
                ArrayTypeAdv.insert(ArrayValueAdv.size() - 2 , 'M' + ArrayType.get(ArrayType.size() - 2))
                Major_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 2)
                Major_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 2)
                Major_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

    if ArrayValueAdv.get(ArrayValueAdv.size() - 1) < Major_LowLevel
        if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mL'
            ArrayTypeAdv.remove(ArrayTypeAdv.size() - 1)
            ArrayTypeAdv.push('ML')
            Major_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
            Major_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
            Major_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)

        else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mHL'
            ArrayTypeAdv.remove(ArrayTypeAdv.size() - 1)
            ArrayTypeAdv.push('M' + ArrayType.get(ArrayType.size() - 1) ) 
            Major_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
            Major_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
            Major_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mLL' or ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'MLL'
            ArrayTypeAdv.remove(ArrayTypeAdv.size() - 1)
            ArrayTypeAdv.push('M' + ArrayType.get(ArrayType.size() - 1))
            Major_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
            Major_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
            Major_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


    //Get Pivot Data
        //Last Pivot Data
if ArrayTypeAdv.size() > 1
    LastPivotType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
    LastPivotIndex := ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
    LastPivotType02 := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)
    LastPivotIndex02 := ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
        //Major
    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) ==  'MHH'
        MajorHighValue01   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 1)
        MajorHighIndex01   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
        MajorHighType01    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        LastMHH            :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)

    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) ==  'MLH'
        MajorHighValue01   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 1)
        MajorHighIndex01   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
        MajorHighType01    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        LastMLH            :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) ==  'MLL'
        MajorLowValue01   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 1)
        MajorLowIndex01   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
        MajorLowType01    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        LastMLL            :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) ==  'MHL'
        MajorLowValue01   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 1)
        MajorLowIndex01   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
        MajorLowType01    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        LastMHL            :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
    
        //Minor
    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) ==  'mHH'
        MinorHighValue01   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 1)
        MinorHighIndex01   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
        MinorHighType01    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        LastmHH            :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) ==  'mLH'
        MinorHighValue01   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 1)
        MinorHighIndex01   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
        MinorHighType01    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        LastmLH            :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) ==  'mLL'
        MinorLowValue01   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 1)
        MinorLowIndex01   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
        MinorLowType01    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        LastmLL           :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) ==  'mHL'
        MinorLowValue01   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 1)
        MinorLowIndex01   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
        MinorLowType01    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
        LastmHL           :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)

    //One to the Last Pivot Data
if ArrayTypeAdv.size() > 1
        //Major
    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) ==  'MHH'
        MajorHighValue02   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
        MajorHighIndex02   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
        MajorHighType02    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) ==  'MLH'
        MajorHighValue02   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
        MajorHighIndex02   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
        MajorHighType02    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) ==  'MLL'
        MajorLowValue02   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
        MajorLowIndex02   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
        MajorLowType02    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) ==  'MHL'
        MajorLowValue02   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
        MajorLowIndex02   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
        MajorLowType02    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

    
        //Minor
    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) ==  'mHH'
        MinorHighValue02   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
        MinorHighIndex02   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
        MinorHighType02    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) ==  'mLH'
        MinorHighValue02   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
        MinorHighIndex02   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
        MinorHighType02    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) ==  'mLL'
        MinorLowValue02   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
        MinorLowIndex02   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
        MinorLowType02    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

    if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) ==  'mHL'
        MinorLowValue02   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
        MinorLowIndex02   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
        MinorLowType02    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

        // Change Pivot Type to Major
    if ArrayTypeAdv.get(ArrayTypeAdv.size()-2) != ArrayTypeAdv.get(ArrayTypeAdv.size()-2)[1] // Change Pivot Type to Major
        //Major
        if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) ==  'MHH'
            MajorHighValue02Ch   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
            MajorHighIndex02Ch   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
            MajorHighType02Ch    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

        if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) ==  'MLH'
            MajorHighValue02Ch   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
            MajorHighIndex02Ch   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
            MajorHighType02Ch    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

        if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) ==  'MLL'
            MajorLowValue02Ch   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
            MajorLowIndex02Ch   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
            MajorLowType02Ch    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

        if  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) ==  'MHL'
            MajorLowValue02Ch   :=  ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
            MajorLowIndex02Ch   :=  ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
            MajorLowType02Ch    :=  ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

    // Detecte Minor level

if ArrayTypeAdv.size() > 2  
    LockDetecteM_MinorLvL := 1
    if str.pos(ArrayTypeAdv.get(ArrayTypeAdv.size() - 1),'m') == 0 and
     str.pos(ArrayTypeAdv.get(ArrayTypeAdv.size() - 2),'m') == 0   and
     str.pos(ArrayTypeAdv.get(ArrayTypeAdv.size() - 3),'M') == 0
        if str.pos(ArrayTypeAdv.get(ArrayTypeAdv.size() - 1),'H') == 2
            Minor_HighLevel := ArrayValueAdv.get(ArrayTypeAdv.size() - 1)
            Minor_LowLevel  := ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
            Minor_HighIndex := ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
            Minor_LowIndex  := ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
            Minor_HighType  := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
            Minor_LowType   := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)
        else if str.pos(ArrayTypeAdv.get(ArrayTypeAdv.size() - 1),'L') == 2
            Minor_HighLevel := ArrayValueAdv.get(ArrayTypeAdv.size() - 2)
            Minor_LowLevel  := ArrayValueAdv.get(ArrayTypeAdv.size() - 1) 
            Minor_HighIndex := ArrayIndexAdv.get(ArrayTypeAdv.size() - 2)
            Minor_LowIndex  := ArrayIndexAdv.get(ArrayTypeAdv.size() - 1)
            Minor_HighType  := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)
            Minor_LowType   := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
    if LockDetecteM_MinorLvL == 1
        //High Minor Detector
        if close > Minor_HighLevel

            if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mHL'     
                Minor_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
                Minor_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
                Minor_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) 
            else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mLL'
                Minor_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
                Minor_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
                Minor_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
            else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mLH' or ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mHH'
                if ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) == 'mHL'     
                    Minor_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 2)
                    Minor_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 2)
                    Minor_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)
                else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) == 'mLL'
                    Minor_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 2)
                    Minor_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 2)
                    Minor_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)
                    

        if  ArrayValueAdv.get(ArrayValueAdv.size() - 1) > Minor_HighLevel

            if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mLH' 
                Minor_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
                Minor_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
                Minor_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) 
                Minor_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 2)
                Minor_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 2)
                Minor_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)                    
            else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mHH'
                Minor_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
                Minor_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
                Minor_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
                Minor_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 2)
                Minor_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 2)
                Minor_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

        //Low Minor Detector
        if close < Minor_LowLevel

            if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mLH'     
                Minor_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
                Minor_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
                Minor_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
            else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mHH'
                Minor_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
                Minor_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
                Minor_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
            else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mHL' or ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mLL'
                if ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) == 'mLH'     
                    Minor_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 2)
                    Minor_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 2)
                    Minor_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)
                else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 2) == 'mHH'
                    Minor_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 2)
                    Minor_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 2)
                    Minor_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

        if ArrayValueAdv.get(ArrayValueAdv.size() - 1) < Minor_LowLevel
            if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mHL' 
                Minor_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
                Minor_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
                Minor_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
                Minor_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 2)
                Minor_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 2)
                Minor_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)
            else if ArrayTypeAdv.get(ArrayTypeAdv.size() - 1) == 'mLL' 
                Minor_LowLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 1)
                Minor_LowIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 1)
                Minor_LowType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 1)
                Minor_HighLevel := ArrayValueAdv.get(ArrayValueAdv.size() - 2)
                Minor_HighIndex := ArrayIndexAdv.get(ArrayIndexAdv.size() - 2)
                Minor_HighType := ArrayTypeAdv.get(ArrayTypeAdv.size() - 2)

    //Reset Minor Levels
    if str.pos(ArrayTypeAdv.get(ArrayTypeAdv.size() - 1),'M') == 0
        LockDetecteM_MinorLvL := 0
        Minor_HighLevel := na
        Minor_LowLevel  := na
        Minor_HighIndex := na
        Minor_LowIndex  := na
        Minor_HighType  := na
        Minor_LowType   := na
        InternalTrend   := 'No Trend'


    //ChoCh and BoS Detector
        //Bos and ChoCh Line
            //Major

if  ta.crossover(close , Major_HighLevel) and  LockBreak_M != Major_HighIndex // Bullish BoS Detector
    if (ExternalTrend == 'No Trend' or ExternalTrend == 'Up Trend')
        Bullish_Major_BoS := true
        BoS_MajorType.push('Bull Major BoS')
        BoS_MajorIndex.push(bar_index)
        LockBreak_M := Major_HighIndex
        ExternalTrend := 'Up Trend'
    else if ExternalTrend == 'Down Trend' // Bullish ChoCh Detector
        Bullish_Major_ChoCh := true
        ChoCh_MajorType.push('Bull Major ChoCh')
        ChoCh_MajorIndex.push(bar_index)
        LockBreak_M := Major_HighIndex
        ExternalTrend := 'Up Trend'
else
    Bullish_Major_ChoCh := false
    Bullish_Major_BoS   := false 


if  ta.crossunder(close, Major_LowLevel) and  LockBreak_M!= Major_LowIndex // Bearish BoS Detector
    if ExternalTrend == 'No Trend' or ExternalTrend == 'Down Trend'
        Bearish_Major_BoS := true
        BoS_MajorType.push('Bear Major BoS')
        BoS_MajorIndex.push(bar_index)
        LockBreak_M := Major_LowIndex
        ExternalTrend := 'Down Trend' 
    else if ExternalTrend == 'Up Trend' // Bearish ChoCh Detector
        Bearish_Major_ChoCh := true
        ChoCh_MajorType.push('Bear Major ChoCh')
        ChoCh_MajorIndex.push(bar_index)
        LockBreak_M := Major_LowIndex
        ExternalTrend := 'Down Trend'
else 
    Bearish_Major_ChoCh := false 
    Bearish_Major_BoS   := false 


            //Minor

if  Minor_HighLevel < close  and  LockBreak_m != Minor_HighIndex // Bullish BoS Detector
    if (InternalTrend == 'No Trend' or InternalTrend == 'Up Trend') 
        Bullish_Minor_BoS   := true
        BoS_MinorType.push('Bull Minor BoS')
        BoS_MinorIndex.push(bar_index)
        LockBreak_m := Minor_HighIndex
        InternalTrend := 'Up Trend'
    else if InternalTrend == 'Down Trend' // Bullish ChoCh Detector
        Bullish_Minor_ChoCh := true
        ChoCh_MinorType.push('Bull Minor ChoCh')
        ChoCh_MinorIndex.push(bar_index)
        LockBreak_m := Minor_HighIndex
        InternalTrend := 'Up Trend'
else 
    Bullish_Minor_ChoCh := false
    Bullish_Minor_BoS   := false


if  Minor_LowLevel > close and  LockBreak_m!= Minor_LowIndex // Bearish BoS Detector
    if InternalTrend == 'No Trend' or InternalTrend == 'Down Trend'
        Bearish_Minor_BoS   := true
        BoS_MinorType.push('Bear Minor BoS')
        BoS_MinorIndex.push(bar_index)
        LockBreak_m := Minor_LowIndex
        InternalTrend := 'Down Trend'
    else if InternalTrend == 'Up Trend' // Bearish ChoCh Detector
        Bearish_Minor_ChoCh := true
        ChoCh_MinorType.push('Bear Minor ChoCh')
        ChoCh_MinorIndex.push(bar_index)
        LockBreak_m := Minor_LowIndex
        InternalTrend := 'Down Trend'
else
    Bearish_Minor_ChoCh := false
    Bearish_Minor_BoS   := false
 

//Order Block Data
    //Demand Major Main and Sub Order Blocks Data , ChoCh Origin

if ArrayIndexAdv.size() > 4 
    ChBuLowest := ta.lowest(bar_index - LastMLL)
    for i = 0 to bar_index - LastMLL
        if low[i] > ChBuLowest
            CorrectBuIndex :=  CorrectBuIndex + 1
        else     
            CorrectBuIndex := 0 

    ChBuLowest := ta.lowest(bar_index - LastPivotIndex02)
    for i = 0 to bar_index - LastPivotIndex02
        if low[i] > ChBuLowest
            CorrectBuIndexSub :=  CorrectBuIndexSub + 1
        else     
            CorrectBuIndexSub := 0

if Bullish_Major_ChoCh and ArrayIndexAdv.size() > 2
    Last02MLL := LastMLL[1]
    if LastPivotType == 'MLL' and low[bar_index - LastMLL] <= ChBuLowest
        if LastPivotType == LastPivotType[1] 
            BuMChMain_Trigger := true
            BuMChMain_Index     := LastMLL

        else if LastPivotType != LastPivotType[1] //Change Last Pivot from mLL to MLL
            if low[bar_index - Last02MLL] < low[bar_index - LastMLL]
                BuMChMain_Trigger := true
                BuMChMain_Index     := Last02MLL               
                BuMChSub_Trigger := true
                BuMChSub_Index     := LastMLL
                
            else if low[bar_index - Last02MLL] > low[bar_index - LastMLL]
                BuMChMain_Trigger := true
                BuMChMain_Index     := LastMLL
              
    else if LastPivotType == 'MLL' and low[bar_index - LastMLL] > ChBuLowest
        if LastPivotType == LastPivotType[1] 
            BuMChMain_Trigger := true
            BuMChMain_Index     := LastMLL+ CorrectBuIndex

        else if LastPivotType != LastPivotType[1] //Change Last Pivot from mLL to MLL
            BuMChMain_Trigger  := true
            BuMChMain_Index     := LastMLL+ CorrectBuIndex
            if LastMHL > LastMLL + CorrectBuIndex
                BuMChSub_Trigger := true
                BuMChSub_Index     := LastMLL

    else if LastPivotType == 'MHL' and low[bar_index - LastMLL] <= ChBuLowest
        BuMChMain_Trigger := true
        BuMChMain_Index     := LastMLL
        BuMChSub_Trigger := true
        BuMChSub_Index     := LastMHL
    
    else if LastPivotType == 'MHL' and low[bar_index - LastMLL] > ChBuLowest
        BuMChMain_Trigger := true
        BuMChMain_Index     := LastMLL + CorrectBuIndex

        if LastMHL > LastMLL + CorrectBuIndex
            BuMChSub_Trigger := true
            BuMChSub_Index     := LastMHL
 
    else if LastPivotType == 'mHH' or LastPivotType == 'mLH'  or LastPivotType == 'MLH'  or LastPivotType == 'MHH' 
        if low[bar_index - LastMLL] <= ChBuLowest
            if LastPivotIndex02 == LastMLL
                BuMChMain_Trigger := true
                BuMChMain_Index     := LastMLL
    
            else if LastPivotIndex02 > LastMLL
                BuMChMain_Trigger := true
                BuMChMain_Index     := LastMLL
                if low[bar_index - LastPivotIndex02] <= ChBuLowestSub
                    BuMChSub_Trigger := true
                    BuMChSub_Index     := LastPivotIndex02  
                else if   low[bar_index - LastPivotIndex02] > ChBuLowestSub       
                    BuMChSub_Trigger := true
                    BuMChSub_Index     := LastPivotIndex02 +  CorrectBuIndexSub       
            else if LastPivotIndex02 < LastMLL
                BuMChMain_Trigger := true
                BuMChMain_Index     := LastMLL

        else if  low[bar_index - LastMLL] > ChBuLowest
            BuMChMain_Trigger   := true
            BuMChMain_Index     := LastMLL  + CorrectBuIndex
else
    BuMChMain_Trigger := false
    BuMChSub_Trigger  := false


    //Demand Major Order Blocks Data ,BoS Origin

if ArrayIndexAdv.size() > 10 
    BoSBuLowest := ta.lowest(bar_index - LastPivotIndex)
    for i = 0 to bar_index - LastPivotIndex
        if low[i] > BoSBuLowest
            CorrectBuBoSIndex :=  CorrectBuBoSIndex + 1
        else     
            CorrectBuBoSIndex := 0 

if ArrayIndexAdv.size() > 10
    BoSBuLowest02 := ta.lowest(bar_index - LastPivotIndex02)
    for i = 0 to bar_index - LastPivotIndex02
        if low[i] > BoSBuLowest02
            CorrectBuBoSIndex02 :=  CorrectBuBoSIndex02 + 1
        else     
            CorrectBuBoSIndex02 := 0 


if Bullish_Major_BoS and ArrayIndexAdv.size() > 2 

    if (LastPivotType == 'MHL' or LastPivotType == 'mHL' or 
         LastPivotType == 'MLL' or LastPivotType == 'mLL') and low[bar_index - LastPivotIndex] <= BoSBuLowest

        BuMBoS_Trigger := true
        BuMBoS_Index   := LastPivotIndex 

    if (LastPivotType == 'MHL' or LastPivotType == 'mHL' or 
         LastPivotType == 'MLL' or LastPivotType == 'mLL') and low[bar_index - LastPivotIndex] > BoSBuLowest

        BuMBoS_Trigger := true
        BuMBoS_Index   := LastPivotIndex + CorrectBuBoSIndex    

    if (LastPivotType == 'mHH' or LastPivotType == 'mLH' or 
     LastPivotType == 'MHH' or LastPivotType == 'MLH') and low[bar_index - LastPivotIndex02] <= BoSBuLowest02

        BuMBoS_Trigger := true
        BuMBoS_Index   := LastPivotIndex02

    if (LastPivotType == 'mHH' or LastPivotType == 'mLH' or 
     LastPivotType == 'MHH' or LastPivotType == 'MLH') and low[bar_index - LastPivotIndex02] > BoSBuLowest02

        BuMBoS_Trigger := true
        BuMBoS_Index   := LastPivotIndex02 + CorrectBuBoSIndex02

else
    BuMBoS_Trigger := false


    //Supply Major Main and Sub Order Blocks Data , ChoCh Origin

if ArrayIndexAdv.size() > 4 
    ChBeHighest := ta.highest(bar_index - LastMHH)
    for i = 0 to bar_index - LastMHH
        if high[i] < ChBeHighest
            CorrectBeIndex :=  CorrectBeIndex + 1
        else     
            CorrectBeIndex := 0 

    ChBeHighestSub := ta.highest(bar_index - LastPivotIndex02)
    for i = 0 to bar_index - LastPivotIndex02
        if high[i] < ChBeHighestSub
            CorrectBeIndexSub :=  CorrectBeIndexSub + 1
        else     
            CorrectBeIndexSub := 0 


if Bearish_Major_ChoCh and ArrayIndexAdv.size() > 2
    Last02MHH := LastMHH[1]
    if LastPivotType == 'MHH' and high[bar_index - LastMHH] >= ChBeHighest
        if LastPivotType == LastPivotType[1]
            BeMChMain_Trigger :=  true
            BeMChMain_Index   :=  LastMHH

        else if LastPivotType != LastPivotType[1] //Change Last Pivot from MHH to MHH
            if high[bar_index - Last02MHH] > high[bar_index - LastMHH]
                BeMChMain_Trigger := true
                BeMChMain_Index   := Last02MHH
                BeMChSub_Trigger  := true
                BeMChSub_Index    := LastMHH

            else if high[bar_index - Last02MHH] < high[bar_index - LastMHH]
                BeMChMain_Trigger :=  true
                BeMChMain_Index   :=  LastMHH

    else if LastPivotType == 'MHH' and high[bar_index - LastMHH] < ChBeHighest
        if LastPivotType == LastPivotType[1] 
            BeMChMain_Trigger :=  true
            BeMChMain_Index   :=  LastMHH + CorrectBeIndex

        else if LastPivotType != LastPivotType[1] //Change Last Pivot from MHH to MHH
            BeMChMain_Trigger :=  true
            BeMChMain_Index   :=  LastMHH + CorrectBeIndex
            if  LastMLH > LastMHH + CorrectBuIndex
                BeMChSub_Trigger  := true
                BeMChSub_Index    := LastMHH


    else if LastPivotType == 'MLH' and  high[bar_index - LastMHH] >= ChBeHighest
        
        BeMChMain_Trigger :=  true
        BeMChMain_Index   :=  LastMHH
        BeMChSub_Trigger  :=  true
        BeMChSub_Index    :=  LastMLH

    else if LastPivotType == 'MLH' and high[bar_index - LastMHH] < ChBeHighest
        BeMChMain_Trigger :=  true
        BeMChMain_Index   :=  LastMHH + CorrectBeIndex

        if LastMLH > LastMHH + CorrectBeIndex
            BeMChSub_Trigger  := true
            BeMChSub_Index    := LastMLH

    else if LastPivotType == 'mLL' or LastPivotType == 'mHL' or LastPivotType == 'MHL' or  LastPivotType == 'MLL'
        if high[bar_index - LastMHH] >= ChBeHighest
            if LastPivotIndex02 == LastMHH
                BeMChMain_Trigger :=  true
                BeMChMain_Index   :=  LastMHH
    
            else if LastPivotIndex02 > LastMHH
                BeMChMain_Trigger  :=  true
                BeMChMain_Index   :=  LastMHH
                if high[bar_index -  LastPivotIndex02] >= ChBeHighestSub
                    BeMChSub_Trigger  := true
                    BeMChSub_Index    := LastPivotIndex02
                else if high[bar_index - LastPivotIndex02] < ChBeHighestSub
                    BeMChSub_Trigger  := true
                    BeMChSub_Index    := LastPivotIndex02 + CorrectBeIndexSub            

            else if LastPivotIndex02 < LastMHH
                BeMChMain_Trigger :=  true
                BeMChMain_Index   :=  LastMHH
        else if high[bar_index - LastMHH] < ChBeHighest
            BeMChMain_Trigger :=  true
            BeMChMain_Index   :=  LastMHH + CorrectBeIndex
else 
    BeMChMain_Trigger :=  false
    BeMChSub_Trigger  :=  false


    //Supply Major Order Blocks Data , BoS Origin

if ArrayIndexAdv.size() > 10 
    BoSBeHighest = ta.highest(bar_index - LastPivotIndex)
    for i = 0 to bar_index - LastPivotIndex
        if high[i] < BoSBeHighest
            CorrectBeBoSIndex :=  CorrectBeBoSIndex + 1
        else     
            CorrectBeBoSIndex := 0 

if ArrayIndexAdv.size() > 10 
    BoSBeHighest02 = ta.highest(bar_index - LastPivotIndex02)
    for i = 0 to bar_index - LastPivotIndex02
        if high[i] < BoSBeHighest02
            CorrectBeBoSIndex02 :=  CorrectBeBoSIndex02 + 1
        else     
            CorrectBeBoSIndex02 := 0 

if Bearish_Major_BoS and ArrayIndexAdv.size() > 2  

    if (LastPivotType == 'mLH' or LastPivotType == 'mHH' or 
         LastPivotType == 'MLH' or LastPivotType == 'MHH') and high[bar_index - LastPivotIndex] >= BoSBeHighest
        BeMBoS_Trigger := true
        BeMBoS_Index    := LastPivotIndex
    
    if (LastPivotType == 'mLH' or LastPivotType == 'mHH' or 
         LastPivotType == 'MLH' or LastPivotType == 'MHH') and high[bar_index - LastPivotIndex] < BoSBeHighest
        BeMBoS_Trigger := true
        BeMBoS_Index     := LastPivotIndex + CorrectBeBoSIndex

    if (LastPivotType == 'mLL' or LastPivotType == 'mHL' or 
     LastPivotType == 'MLL' or LastPivotType == 'MHL') and high[bar_index - LastPivotIndex02] >= BoSBeHighest02
        BeMBoS_Trigger := true
        BeMBoS_Index     := LastPivotIndex02

    if (LastPivotType == 'mLL' or LastPivotType == 'mHL' or 
     LastPivotType == 'MLL' or LastPivotType == 'MHL') and high[bar_index - LastPivotIndex02] < BoSBeHighest02
        BeMBoS_Trigger := true
        BeMBoS_Index     := LastPivotIndex02 + CorrectBeBoSIndex02

else 
    BeMBoS_Trigger := false


////////////////////////////////////////////////////
///////////////Order Block Refinement///////////////
////////////////////////////////////////////////////

    //Demand
        //Demand Main Zone, ChoCh Origin
[BuMChMain_Xd1, BuMChMain_Xd2, BuMChMain_Yd12, BuMChMain_Xp1, BuMChMain_Xp2, BuMChMain_Yp12] = 
 Refiner.OBRefiner('Demand', RefineDmainCh ? 'On' : 'Off', RefineMeDmainCh ,BuMChMain_Trigger,  BuMChMain_Index)
        //Demand Sub Zone, ChoCh Origin
[BuMChSub_Xd1 , BuMChSub_Xd2 ,  BuMChSub_Yd12, BuMChSub_Xp1 , BuMChSub_Xp2 , BuMChSub_Yp12] = 
 Refiner.OBRefiner('Demand', RefineDsubCh ? 'On' : 'Off', RefineMeDsubCh ,BuMChSub_Trigger,  BuMChSub_Index)
        //Demand All Zone, BoS Origin
[BuMBoS_Xd1, BuMBoS_Xd2, BuMBoS_Yd12, BuMBoS_Xp1, BuMBoS_Xp2, BuMBoS_Yp12] = 
 Refiner.OBRefiner('Demand', RefineDsubCh ? 'On' : 'Off', RefineMeDsubCh,BuMBoS_Trigger, BuMBoS_Index)

    //Supply
        //Supply Main Zone, ChoCh Origin    
[BeMChMain_Xd1, BeMChMain_Xd2, BeMChMain_Yd12, BeMChMain_Xp1, BeMChMain_Xp2, BeMChMain_Yp12] = 
 Refiner.OBRefiner('Supply', RefineSmainCh ? 'On' : 'Off', RefineMeSmainCh ,BeMChMain_Trigger,  BeMChMain_Index)
        //Supply Sub Zone, ChoCh Origin
[BeMChSub_Xd1 , BeMChSub_Xd2 ,  BeMChSub_Yd12, BeMChSub_Xp1 , BeMChSub_Xp2 , BeMChSub_Yp12] = 
 Refiner.OBRefiner('Supply', RefineSsubCh ? 'On' : 'Off', RefineMeSsubCh ,BeMChSub_Trigger,  BeMChSub_Index)
        //Supply All Zone, BoS Origin
[BeMBoS_Xd1, BeMBoS_Xd2, BeMBoS_Yd12, BeMBoS_Xp1, BeMBoS_Xp2, BeMBoS_Yp12] = 
 Refiner.OBRefiner('Supply', RefineSsubCh ? 'On' : 'Off', RefineMeSsubCh,BeMBoS_Trigger, BeMBoS_Index)


/////////////////////////////////////
///////////////Drawing///////////////
/////////////////////////////////////
        //OUTPUT ==> Alert Trigger
[Alert_DMMM, Alert_SMMMbb, PMSBB, DMSBB, IMSBB] = Drawing.OBDrawing('Demand', BuMChMain_Trigger ,BuMChMain_Yd12, BuMChMain_Yp12 ,BuMChMain_Xd1 ,true , OBVaP  ,MLOB ,MLBB , ShowAllOB ,ShowAllBB ,DMOBShow, SMBBShow,DMOBColor, SMBBColor)
[Alert_DSMM, Alert_SSMMbb, PSSBB, DSSBB, ISSBB] = Drawing.OBDrawing('Demand', BuMChSub_Trigger  ,BuMChSub_Yd12 , BuMChSub_Yp12  ,BuMChSub_Xd1  ,true , OBVaP  ,MLOB ,MLBB , ShowAllOB ,ShowAllBB ,DSOBShow, SSBBShow,DSOBColor, SSBBColor)
[Alert_DAMM, Alert_SAMMbb, PASBB, DASBB, IASBB] = Drawing.OBDrawing('Demand', BuMBoS_Trigger    , BuMBoS_Yd12  , BuMBoS_Yp12    , BuMBoS_Xd1   ,true , OBVaP  ,MLOB ,MLBB , ShowAllOB ,ShowAllBB ,DSOBShow, SSBBShow,DSOBColor, SSBBColor)

[Alert_SMMM, Alert_DMMMbb, PMDBB, DMDBB, IMDBB] = Drawing.OBDrawing('Supply', BeMChMain_Trigger ,BeMChMain_Yd12, BeMChMain_Yp12 ,BeMChMain_Xd1,true , OBVaP   ,MLOB ,MLBB , ShowAllOB ,ShowAllBB ,SMOBShow, DMBBShow,SMOBColor, DMBBColor)
[Alert_SSMM, Alert_DSMMbb, PSDBB, DSDBB, ISDBB] = Drawing.OBDrawing('Supply', BeMChSub_Trigger  ,BeMChSub_Yd12 , BeMChSub_Yp12  ,BeMChSub_Xd1 ,true , OBVaP   ,MLOB ,MLBB , ShowAllOB ,ShowAllBB ,SSOBShow, DSBBShow,SSOBColor, DSBBColor)
[Alert_SAMM, Alert_DAMMbb, PADBB, DADBB, IADBB] = Drawing.OBDrawing('Supply', BeMBoS_Trigger    , BeMBoS_Yd12  , BeMBoS_Yp12    ,BeMBoS_Xd1   ,true , OBVaP   ,MLOB ,MLBB , ShowAllOB ,ShowAllBB ,SSOBShow, DSBBShow,SSOBColor, DSBBColor)

/////////////////////////////////////
//////////OverLappingDrawing/////////
/////////////////////////////////////

[Alert_DMainM] = OLB.OBOverlappingDrawing('Demand', BuMChMain_Trigger , DMDBB , PMDBB,  BuMChMain_Yd12, BuMChMain_Yp12 ,BuMChMain_Xd1 ,true, OBVaP, MLOL, ShowAllOLB, DOLBShow,DOLBColor) 
[Alert_DMainS] = OLB.OBOverlappingDrawing('Demand', BuMChMain_Trigger , DSDBB , PSDBB,  BuMChMain_Yd12, BuMChMain_Yp12 ,BuMChMain_Xd1 ,true, OBVaP, MLOL, ShowAllOLB, DOLBShow,DOLBColor)
[Alert_DMainA] = OLB.OBOverlappingDrawing('Demand', BuMChMain_Trigger , DADBB , PADBB,  BuMChMain_Yd12, BuMChMain_Yp12 ,BuMChMain_Xd1 ,true, OBVaP, MLOL, ShowAllOLB, DOLBShow,DOLBColor)

[Alert_DSubM]  = OLB.OBOverlappingDrawing('Demand', BuMChSub_Trigger  , DMDBB , PMDBB,  BuMChSub_Yd12 , BuMChSub_Yp12  ,BuMChSub_Xd1  ,true, OBVaP, MLOL, ShowAllOLB, DOLBShow,DOLBColor)
[Alert_DSubS]  = OLB.OBOverlappingDrawing('Demand', BuMChSub_Trigger  , DSDBB , PSDBB,  BuMChSub_Yd12 , BuMChSub_Yp12  ,BuMChSub_Xd1  ,true, OBVaP, MLOL, ShowAllOLB, DOLBShow,DOLBColor)
[Alert_DSubA]  = OLB.OBOverlappingDrawing('Demand', BuMChSub_Trigger  , DADBB , PADBB,  BuMChSub_Yd12 , BuMChSub_Yp12  ,BuMChSub_Xd1  ,true, OBVaP, MLOL, ShowAllOLB, DOLBShow,DOLBColor)

[Alert_DBoSM]  = OLB.OBOverlappingDrawing('Demand', BuMBoS_Trigger    , DMDBB , PMDBB,  BuMBoS_Yd12   , BuMBoS_Yp12    , BuMBoS_Xd1   ,true, OBVaP, MLOL, ShowAllOLB, DOLBShow,DOLBColor)
[Alert_DBoSS]  = OLB.OBOverlappingDrawing('Demand', BuMBoS_Trigger    , DSDBB , PSDBB,  BuMBoS_Yd12   , BuMBoS_Yp12    , BuMBoS_Xd1   ,true, OBVaP, MLOL, ShowAllOLB, DOLBShow,DOLBColor)
[Alert_DBoSA]  = OLB.OBOverlappingDrawing('Demand', BuMBoS_Trigger    , DADBB , PADBB,  BuMBoS_Yd12   , BuMBoS_Yp12    , BuMBoS_Xd1   ,true, OBVaP, MLOL, ShowAllOLB, DOLBShow,DOLBColor)


[Alert_SMainM] = OLB.OBOverlappingDrawing('Supply', BeMChMain_Trigger , DMSBB , PMSBB,  BeMChMain_Yd12, BeMChMain_Yp12 ,BeMChMain_Xd1 ,true, OBVaP, MLOL, ShowAllOLB, SOLBBShow,SOLBColor) 
[Alert_SMainS] = OLB.OBOverlappingDrawing('Supply', BeMChMain_Trigger , DSSBB , PSSBB,  BeMChMain_Yd12, BeMChMain_Yp12 ,BeMChMain_Xd1 ,true, OBVaP, MLOL, ShowAllOLB, SOLBBShow,SOLBColor) 
[Alert_SMainA] = OLB.OBOverlappingDrawing('Supply', BeMChMain_Trigger , DASBB , PASBB,  BeMChMain_Yd12, BeMChMain_Yp12 ,BeMChMain_Xd1 ,true, OBVaP, MLOL, ShowAllOLB, SOLBBShow,SOLBColor) 

[Alert_SSubM]  = OLB.OBOverlappingDrawing('Supply', BeMChSub_Trigger  , DMSBB , PMSBB,  BeMChSub_Yd12 , BeMChSub_Yp12  ,BeMChSub_Xd1  ,true, OBVaP, MLOL, ShowAllOLB, SOLBBShow,SOLBColor)
[Alert_SSubS]  = OLB.OBOverlappingDrawing('Supply', BeMChSub_Trigger  , DSSBB , PSSBB,  BeMChSub_Yd12 , BeMChSub_Yp12  ,BeMChSub_Xd1  ,true, OBVaP, MLOL, ShowAllOLB, SOLBBShow,SOLBColor)
[Alert_SSubA]  = OLB.OBOverlappingDrawing('Supply', BeMChSub_Trigger  , DASBB , PASBB,  BeMChSub_Yd12 , BeMChSub_Yp12  ,BeMChSub_Xd1  ,true, OBVaP, MLOL, ShowAllOLB, SOLBBShow,SOLBColor)

[Alert_SBoSM]  = OLB.OBOverlappingDrawing('Supply', BeMBoS_Trigger    , DMSBB , PMSBB,  BeMBoS_Yd12   , BeMBoS_Yp12    , BeMBoS_Xd1   ,true, OBVaP, MLOL, ShowAllOLB, SOLBBShow,SOLBColor)
[Alert_SBoSS]  = OLB.OBOverlappingDrawing('Supply', BeMBoS_Trigger    , DSSBB , PSSBB,  BeMBoS_Yd12   , BeMBoS_Yp12    , BeMBoS_Xd1   ,true, OBVaP, MLOL, ShowAllOLB, SOLBBShow,SOLBColor)
[Alert_SBoSA]  = OLB.OBOverlappingDrawing('Supply', BeMBoS_Trigger    , DASBB , PASBB,  BeMBoS_Yd12   , BeMBoS_Yp12    , BeMBoS_Xd1   ,true, OBVaP, MLOL, ShowAllOLB, SOLBBShow,SOLBColor)


///////////////////////////////////
///////////////Alert///////////////
///////////////////////////////////
BULLSIGNAL = Alert_DMainM or Alert_DMainS or Alert_DMainA or Alert_DSubM or Alert_DSubS or Alert_DSubA or Alert_DBoSM or Alert_DBoSS or Alert_DBoSA
BEARSIGNAL = Alert_SMainM or Alert_SMainS or Alert_SMainA or Alert_SSubM or Alert_SSubS or Alert_SSubA or Alert_SBoSM or Alert_SBoSS or Alert_DBoSA 

Alert.AlertSender(BULLSIGNAL  , Alert_OLP, AlertName, 'Bullish', 'Order Block Signal', 'Full' ,Frequncy, UTC, "Off", 'Long position in Demand Order Block' , open, high, low, close,0,0,0, 0 , 0)
Alert.AlertSender(BEARSIGNAL  , Alert_OLP, AlertName, 'Bearish', 'Order Block Signal', 'Full' ,Frequncy, UTC, "Off", 'Short position in Supply Breaker Block' , open, high, low, close,0,0,0, 0,0)